{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "plt.rcParams[\"figure.dpi\"] = 160\n",
    "\n",
    "def remove_frame():\n",
    "    for spine in plt.gca().spines.values():\n",
    "        spine.set_visible(False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<torch._C.Generator at 0x7f5ea5c7d5b0>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "torch.manual_seed(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n_samples = 10000\n",
    "# max_length = 10\n",
    "\n",
    "# X = []\n",
    "# y = []\n",
    "\n",
    "# for i in range(n_samples):\n",
    "#     x_i = np.random.rand(np.random.randint(max_length) + 1)\n",
    "    \n",
    "#     if np.random.rand() < 0.5 or np.all(x_i == np.sort(x_i)):\n",
    "#         x_i = np.sort(x_i)\n",
    "#         if np.random.rand() < 0.5:\n",
    "#             x_i = x_i[::-1]\n",
    "            \n",
    "#         y.append(1)\n",
    "#     else:\n",
    "#         y.append(0)\n",
    "        \n",
    "#     X.append(x_i.reshape(-1,1))\n",
    "        \n",
    "# y = np.array(y).reshape(-1, 1)\n",
    "\n",
    "# from sklearn.model_selection import train_test_split\n",
    "# indices = np.array(range(len(X_binary)))\n",
    "# train, test = train_test_split(indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_samples = 10000\n",
    "n_symbols = 5\n",
    "max_length = 10\n",
    "\n",
    "X = []\n",
    "X_binary = []\n",
    "y = []\n",
    "\n",
    "for i in range(n_samples):\n",
    "    x_i = np.random.randint(n_symbols, size=np.random.randint(max_length) + 1)\n",
    "    len_i = len(x_i)\n",
    "    \n",
    "    if np.random.rand() < 0.5:\n",
    "        if len_i % 2 == 0:\n",
    "            x_i[:len_i//2] = x_i[len_i//2:][::-1]\n",
    "        else:\n",
    "            x_i[:len_i//2] = x_i[len_i//2+1:][::-1]\n",
    "        y.append(1)\n",
    "    else:\n",
    "        if len_i % 2 == 0:\n",
    "            if np.all(x_i[:len_i//2] == x_i[len_i//2:][::-1]):\n",
    "                y.append(1)\n",
    "            else:\n",
    "                y.append(0)\n",
    "        else:\n",
    "            if np.all(x_i[:len_i//2] == x_i[len_i//2+1:][::-1]):\n",
    "                y.append(1)\n",
    "            else:\n",
    "                y.append(0)\n",
    "\n",
    "    X.append(x_i) \n",
    "            \n",
    "for x_i in X:\n",
    "    b = np.zeros((len(x_i), n_symbols))\n",
    "    for j, x_ij in enumerate(x_i):\n",
    "        b[j, x_ij] = 1\n",
    "    X_binary.append(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "indices = np.array(range(len(X_binary)))\n",
    "train, test = train_test_split(indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Elman(nn.Module):\n",
    "    def __init__(self, num_features, num_hidden, num_layers=1):\n",
    "        super(Elman, self).__init__()\n",
    "        self.rnn = nn.RNN(num_features, num_hidden, num_layers=num_layers, batch_first=True)\n",
    "        self.fc = nn.Linear(num_hidden, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out, hn = self.rnn(x)\n",
    "        if self.rnn.num_layers > 1:\n",
    "            hn = hn[-1, :]\n",
    "        out = self.fc(hn)\n",
    "        return out.view(-1, 1).sigmoid()\n",
    "    \n",
    "class LSTM(nn.Module):\n",
    "    def __init__(self, num_features, num_hidden, num_layers=1):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.rnn = nn.LSTM(num_features, num_hidden, num_layers=num_layers, batch_first=True)\n",
    "        self.fc = nn.Linear(num_hidden, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out, (hn, cn) = self.rnn(x)\n",
    "        out = self.fc(hn)\n",
    "        return out.view(-1, 1).sigmoid()\n",
    "    \n",
    "class GRU(nn.Module):\n",
    "    def __init__(self, num_features, num_hidden, num_layers=1):\n",
    "        super(GRU, self).__init__()\n",
    "        self.rnn = nn.GRU(num_features, num_hidden, num_layers=num_layers, batch_first=True)\n",
    "        self.fc = nn.Linear(num_hidden, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out, hn = self.rnn(x)\n",
    "        out = self.fc(hn)\n",
    "        return out.view(-1, 1).sigmoid()\n",
    "    \n",
    "class BiGRU(nn.Module):\n",
    "    def __init__(self, num_features, num_hidden, num_layers=1):\n",
    "        super(BiGRU, self).__init__()\n",
    "        self.rnn = nn.GRU(num_features, num_hidden, num_layers=num_layers, batch_first=True, bidirectional=True)\n",
    "        self.fc = nn.Linear(2*num_hidden, 1)\n",
    "        \n",
    "        self.num_hidden = num_hidden\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out, hn = self.rnn(x)\n",
    "\n",
    "        if self.rnn.num_layers > 1:\n",
    "            hn = hn[-2:, :]\n",
    "        \n",
    "        out = self.fc(hn.view(-1, 2*self.num_hidden))\n",
    "        return out.view(-1, 1).sigmoid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_curves = {}\n",
    "models = {}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: [0/25], Step: Loss: 0.6995\n",
      "Epoch: [0/25], Step: Loss: 0.6672\n",
      "Epoch: [1/25], Step: Loss: 0.6488\n",
      "Epoch: [2/25], Step: Loss: 0.6259\n",
      "Epoch: [3/25], Step: Loss: 0.5766\n",
      "Epoch: [4/25], Step: Loss: 0.5387\n",
      "Epoch: [5/25], Step: Loss: 0.5058\n",
      "Epoch: [6/25], Step: Loss: 0.4785\n",
      "Epoch: [7/25], Step: Loss: 0.4487\n",
      "Epoch: [8/25], Step: Loss: 0.4217\n",
      "Epoch: [9/25], Step: Loss: 0.3954\n",
      "Epoch: [10/25], Step: Loss: 0.3741\n",
      "Epoch: [11/25], Step: Loss: 0.3587\n",
      "Epoch: [12/25], Step: Loss: 0.3481\n",
      "Epoch: [13/25], Step: Loss: 0.3357\n",
      "Epoch: [14/25], Step: Loss: 0.3257\n",
      "Epoch: [15/25], Step: Loss: 0.3181\n",
      "Epoch: [16/25], Step: Loss: 0.3115\n",
      "Epoch: [17/25], Step: Loss: 0.3065\n",
      "Epoch: [18/25], Step: Loss: 0.3028\n",
      "Epoch: [19/25], Step: Loss: 0.2999\n",
      "Epoch: [20/25], Step: Loss: 0.2973\n",
      "Epoch: [21/25], Step: Loss: 0.2953\n",
      "Epoch: [22/25], Step: Loss: 0.2930\n",
      "Epoch: [23/25], Step: Loss: 0.2908\n",
      "Epoch: [24/25], Step: Loss: 0.2887\n"
     ]
    }
   ],
   "source": [
    "for model, name in [(Elman(n_symbols, 10), \"elman\"),\n",
    "                    (Elman(n_symbols, 10, num_layers=2), \"elman-stacked\"),\n",
    "                    (LSTM(n_symbols, 10), \"lstm\"),\n",
    "                    (GRU(n_symbols, 10), \"gru\"),]:\n",
    "                    (#BiGRU(n_symbols, 5), \"bigru\")]:\n",
    "    \n",
    "    models[name] = model\n",
    "    criterion = nn.BCELoss()  \n",
    "    optimizer = torch.optim.Adam(model.parameters(), amsgrad=True)  \n",
    "\n",
    "    num_epochs = 25 \n",
    "    test_loss = []\n",
    "\n",
    "    l = 0\n",
    "    for i in test:\n",
    "        x_i = torch.Tensor(X_binary[i:i+1])\n",
    "        y_i = torch.Tensor(y[i:i+1])\n",
    "        outputs = model(x_i)\n",
    "        loss = criterion(outputs, y_i)\n",
    "        l += loss       \n",
    "\n",
    "    print('Epoch: [%d/%d], Step: Loss: %.4f' \n",
    "          % (0, num_epochs, l / len(test)))\n",
    "    test_loss.append(l / len(test))\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        for i in train:       \n",
    "            optimizer.zero_grad()\n",
    "\n",
    "            x_i = torch.Tensor(X_binary[i:i+1])\n",
    "            y_i = torch.Tensor(y[i:i+1])\n",
    "\n",
    "            outputs = model(x_i)\n",
    "            loss = criterion(outputs, y_i)\n",
    "            loss.backward()\n",
    "\n",
    "            optimizer.step()\n",
    "\n",
    "        l = 0\n",
    "        for i in test:\n",
    "            x_i = torch.Tensor(X_binary[i:i+1])\n",
    "            y_i = torch.Tensor(y[i:i+1])\n",
    "            outputs = model(x_i)\n",
    "            loss = criterion(outputs, y_i)\n",
    "            l += loss       \n",
    "\n",
    "        print('Epoch: [%d/%d], Step: Loss: %.4f' \n",
    "              % (epoch, num_epochs, l / len(test)))\n",
    "        test_loss.append(l / len(test))\n",
    "        \n",
    "    test_curves[name] = np.array([v.detach().numpy() for v in test_loss])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'elman': array([0.6977668 , 0.6323324 , 0.62450373, 0.62146044, 0.57789624,\n",
       "        0.5349363 , 0.4990144 , 0.48130894, 0.46617988, 0.45721802,\n",
       "        0.45052823, 0.44516122, 0.4414962 , 0.4379384 , 0.4321983 ,\n",
       "        0.42754042, 0.4330435 , 0.4308325 , 0.42581293, 0.41797188,\n",
       "        0.41178882, 0.40919796, 0.40603667, 0.40201536, 0.39762527,\n",
       "        0.39843547], dtype=float32),\n",
       " 'elman-stacked': array([0.6870105 , 0.6275273 , 0.6225325 , 0.60538054, 0.5544928 ,\n",
       "        0.5078323 , 0.49336988, 0.47463822, 0.4471512 , 0.43431422,\n",
       "        0.4303494 , 0.43525845, 0.3825954 , 0.3713335 , 0.3712768 ,\n",
       "        0.36546677, 0.41314447, 0.36470494, 0.36591393, 0.38894305,\n",
       "        0.38513866, 0.37507415, 0.3854914 , 0.36508697, 0.37022692,\n",
       "        0.37122142], dtype=float32),\n",
       " 'lstm': array([0.68603784, 0.6280198 , 0.6101758 , 0.59064204, 0.54072195,\n",
       "        0.47209877, 0.4428825 , 0.3971521 , 0.33493873, 0.29846343,\n",
       "        0.27864918, 0.26603928, 0.25537416, 0.24558868, 0.235362  ,\n",
       "        0.22567134, 0.2162321 , 0.20650567, 0.19744694, 0.18914443,\n",
       "        0.18406127, 0.17746834, 0.16882439, 0.15734874, 0.14670397,\n",
       "        0.13962978], dtype=float32),\n",
       " 'gru': array([0.69799966, 0.63215774, 0.45587665, 0.35430762, 0.3009218 ,\n",
       "        0.27921155, 0.26679534, 0.25907862, 0.23129143, 0.2148707 ,\n",
       "        0.20358989, 0.19402692, 0.18562165, 0.17677782, 0.16728964,\n",
       "        0.15873297, 0.15118805, 0.14508775, 0.13995707, 0.13587168,\n",
       "        0.13258748, 0.1298337 , 0.12740989, 0.12525153, 0.12327324,\n",
       "        0.12149658], dtype=float32)}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_curves"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 960x640 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(num_epochs+1), test_curves[\"elman\"], c=\"r\", label=\"Elman\")\n",
    "#plt.plot(range(num_epochs+1), test_curves[\"elman-stacked\"], \"r--\", label=\"Elman 2-layer\")\n",
    "#plt.plot(range(num_epochs+1), test_curves[\"lstm\"], c=\"b\", label=\"LSTM\")\n",
    "#plt.plot(range(num_epochs+1), test_curves[\"gru\"], c=\"g\", label=\"GRU\")\n",
    "plt.ylim(0,0.75)\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "remove_frame()\n",
    "plt.savefig(\"palindrome-1.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test = []\n",
    "y_test = []\n",
    "\n",
    "for i in range(25000):\n",
    "    x_i = np.random.randint(n_symbols, size=np.random.randint(2*max_length) + 1)\n",
    "    len_i = len(x_i)\n",
    "    \n",
    "    if np.random.rand() < 0.5:\n",
    "        if len_i % 2 == 0:\n",
    "            x_i[:len_i//2] = x_i[len_i//2:][::-1]\n",
    "        else:\n",
    "            x_i[:len_i//2] = x_i[len_i//2+1:][::-1]\n",
    "        y_test.append(1)\n",
    "    else:\n",
    "        if len_i % 2 == 0:\n",
    "            if np.all(x_i[:len_i//2] == x_i[len_i//2:][::-1]):\n",
    "                y_test.append(1)\n",
    "            else:\n",
    "                y_test.append(0)\n",
    "        else:\n",
    "            if np.all(x_i[:len_i//2] == x_i[len_i//2+1:][::-1]):\n",
    "                y_test.append(1)\n",
    "            else:\n",
    "                y_test.append(0)\n",
    "\n",
    "    X_test.append(x_i) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_binary_test = []\n",
    "\n",
    "for x_i in X_test:\n",
    "    b = np.zeros((len(x_i), n_symbols))\n",
    "    for j, x_ij in enumerate(x_i):\n",
    "        b[j, x_ij] = 1\n",
    "    X_binary_test.append(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 960x640 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = models[\"elman\"]\n",
    "l = np.zeros(2*max_length)\n",
    "counters = np.zeros(2*max_length)\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    x_i = torch.Tensor(X_binary_test[i:i+1])\n",
    "    y_i = torch.Tensor(y_test[i:i+1])\n",
    "    outputs = model(x_i)\n",
    "    loss = criterion(outputs, y_i)\n",
    "    l[len(x_i[0])-1] += loss   \n",
    "    counters[len(x_i[0])-1] += 1\n",
    "    \n",
    "plt.plot(range(1,2*max_length+1),l/counters, color=\"r\", marker=\"o\", label=\"Elman\")\n",
    "\n",
    "model = models[\"elman-stacked\"]\n",
    "l = np.zeros(2*max_length)\n",
    "counters = np.zeros(2*max_length)\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    x_i = torch.Tensor(X_binary_test[i:i+1])\n",
    "    y_i = torch.Tensor(y_test[i:i+1])\n",
    "    outputs = model(x_i)\n",
    "    loss = criterion(outputs, y_i)\n",
    "    l[len(x_i[0])-1] += loss   \n",
    "    counters[len(x_i[0])-1] += 1\n",
    "    \n",
    "plt.plot(range(1,2*max_length+1),l/counters, \"r--\", marker=\"o\", label=\"Elman 2-layer\")\n",
    "\n",
    "model = models[\"lstm\"]\n",
    "l = np.zeros(2*max_length)\n",
    "counters = np.zeros(2*max_length)\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    x_i = torch.Tensor(X_binary_test[i:i+1])\n",
    "    y_i = torch.Tensor(y_test[i:i+1])\n",
    "    outputs = model(x_i)\n",
    "    loss = criterion(outputs, y_i)\n",
    "    l[len(x_i[0])-1] += loss   \n",
    "    counters[len(x_i[0])-1] += 1\n",
    "    \n",
    "plt.plot(range(1,2*max_length+1),l/counters, color=\"b\", marker=\"o\", label=\"LSTM\")\n",
    "\n",
    "model = models[\"gru\"]\n",
    "l = np.zeros(2*max_length)\n",
    "counters = np.zeros(2*max_length)\n",
    "\n",
    "for i in range(len(X_test)):\n",
    "    x_i = torch.Tensor(X_binary_test[i:i+1])\n",
    "    y_i = torch.Tensor(y_test[i:i+1])\n",
    "    outputs = model(x_i)\n",
    "    loss = criterion(outputs, y_i)\n",
    "    l[len(x_i[0])-1] += loss   \n",
    "    counters[len(x_i[0])-1] += 1\n",
    "    \n",
    "plt.plot(range(1,2*max_length+1),l/counters, color=\"g\", marker=\"o\", label=\"GRU\")\n",
    "\n",
    "plt.legend()\n",
    "plt.ylim(0,0.75)\n",
    "plt.grid()\n",
    "remove_frame()\n",
    "plt.savefig(\"length-4.png\")\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
